home *** CD-ROM | disk | FTP | other *** search
/ CICA 1997 August / CICA - The Ultimate Collection of Shareware for Windows (Walnut Creek) (August 1997) (Disc 1).iso / utils / unix / unzip520 / mac / macunzip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-03  |  21.1 KB  |  738 lines
  1. #define UNZIP_INTERNAL
  2. #include "unzip.h"
  3. #include "version.h"
  4.  
  5. #include <Traps.h>
  6. #include <Values.h>
  7.  
  8. char UnzipVersion[32], ZipinfoVersion[32];
  9.  
  10. void MacFSTest (int);
  11. void ResolveMacVol (short, short *, long *, StringPtr);
  12.  
  13. void screenOpen(char *);
  14. void screenControl(char *, int);
  15. void screenClose(void);
  16.  
  17. #define aboutAlert      128
  18.  
  19. #define selectDialog    129
  20. #define okItem          1
  21. #define cancelItem      2
  22. #define editItem        3
  23. #define staticItem      4
  24.  
  25. #define unzipMenuBar    128
  26.  
  27. #define appleMenu       128
  28. #define aboutItem       1
  29.  
  30. #define fileMenu        129
  31. #define extractItem     1
  32. #define infoItem        2
  33. #define listItem        3
  34. #define testItem        4
  35. #define commentItem     6
  36. #define freshenItem     8
  37. #define updateItem      9
  38. #define quitItem        11
  39.  
  40. #define editMenu        130
  41. #define cutItem         1
  42. #define copyItem        2
  43. #define pasteItem       3
  44.  
  45. #define modifierMenu    131
  46. #define excludeItem     1
  47. #define selectItem      2
  48. #define quietItem       9
  49. #define verboseItem     10
  50.  
  51. #define screenMenu      132
  52. #define pauseItem       1
  53. #define scrollItem      2
  54.  
  55. #define extractMenu     133
  56. #define screenItem      3
  57. #define junkItem        5
  58.  
  59. #define caseMenu        134
  60. #define insensitiveItem 1
  61. #define lowercaseItem   2
  62.  
  63. #define convertMenu     135
  64. #define autoItem        1
  65. #define binaryItem      2
  66. #define textItem        3
  67.  
  68. #define overwriteMenu   136
  69. #define alwaysItem      1
  70. #define neverItem       2
  71. #define promptItem      3
  72.  
  73. #define infoMenu        137
  74. #define prtCommentItem  2
  75. #define prtHeaderItem   3
  76. #define prtTotalsItem   4
  77.  
  78. #define formatMenu      138
  79. #define filenameItem    1
  80. #define longItem        2
  81. #define mediumItem      3
  82. #define shortItem       4
  83.  
  84. long modifiers, modifierMask;
  85.  
  86. #define allFlags        0x000FFFFF
  87.  
  88. #define quietFlag       0x00000001
  89. #define verboseFlag     0x00000002
  90.  
  91. #define pauseFlag       0x00080000
  92. #define scrollFlag      0x00040000
  93.  
  94. #define screenFlag      0x00000004
  95. #define junkFlag        0x00000008
  96.  
  97. #define insensitiveFlag 0x00000010
  98. #define lowercaseFlag   0x00000020
  99.  
  100. #define autoFlag        0x00000040
  101. #define textFlag        0x00000080
  102.  
  103. #define neverFlag       0x00000100
  104. #define overwriteFlag   0x00000200
  105.  
  106. #define prtCommentFlag  0x00000400
  107. #define prtHeaderFlag   0x00000800
  108. #define prtTotalsFlag   0x00001000
  109.  
  110. #define filenameFlag    0x00002000
  111. #define longFlag        0x00004000
  112. #define mediumFlag      0x00008000
  113. #define shortFlag       0x00010000
  114.  
  115. #define extractMask     0x000003FD
  116. #define infoMask        0x0001FE02
  117. #define listMask        0x00000001
  118. #define testMask        0x00000001
  119. #define commentMask     0x00000000
  120. #define freshenMask     0x000003FD
  121. #define updateMask      0x000003FD
  122.  
  123. EventRecord myevent;
  124. MenuHandle appleHandle, modifierHandle, screenHandle, extractHandle;
  125. MenuHandle caseHandle, convertHandle, overwriteHandle, infoHandle;
  126. MenuHandle formatHandle;
  127. Handle menubar, itemHandle;
  128. short itemType;
  129. Rect itemRect;
  130.  
  131. char command, fileList[256];
  132.  
  133. Boolean stop;
  134.  
  135. SysEnvRec sysRec;
  136.  
  137. char *macgetenv(s) char *s; {
  138.     if (s == NULL) return(fileList);
  139.     return(NULL);
  140. }
  141.  
  142. Boolean TrapAvailable(machineType, trapNumber, trapType)
  143. short machineType;
  144. short trapNumber;
  145. TrapType trapType;
  146. {
  147.     if (machineType < 0)
  148.         return (false);
  149.  
  150.     if ((trapType == ToolTrap) &&
  151.         (machineType > envMachUnknown) &&
  152.         (machineType < envMacII)) {
  153.         if ((trapNumber &= 0x03FF) > 0x01FF)
  154.             trapNumber = _Unimplemented;
  155.     }
  156.     return (NGetTrapAddress(trapNumber, trapType) !=
  157.         GetTrapAddress(_Unimplemented));
  158. }
  159.  
  160. void domenu(menucommand) long menucommand;
  161. {
  162.     short themenu, theitem;
  163.     DialogPtr thedialog;
  164.     Str255 name;
  165.     long check;
  166.  
  167.     themenu = HiWord(menucommand);
  168.     theitem = LoWord(menucommand);
  169.  
  170.     switch (themenu) {
  171.  
  172.     case appleMenu:
  173.         if (theitem == aboutItem) {
  174.             ParamText((StringPtr)UnzipVersion, (StringPtr)ZipinfoVersion, nil, nil);
  175.             Alert(aboutAlert, nil);
  176.         } else {
  177.             GetItem(appleHandle, theitem, name);
  178.             theitem = OpenDeskAcc(name);
  179.         }
  180.         break;
  181.  
  182.     case fileMenu:
  183.         switch (theitem) {
  184.         case extractItem:
  185.             if (modifiers & screenFlag)
  186.                 command = 'c';
  187.             else
  188.                 command = 'x';
  189.             modifierMask = extractMask;
  190.             break;
  191.         case infoItem:
  192.             command = 'Z';
  193.             modifierMask = infoMask;
  194.             break;
  195.         case listItem:
  196.             if (modifiers & verboseFlag)
  197.                 command = 'v';
  198.             else
  199.                 command = 'l';
  200.             modifierMask = listMask;
  201.             break;
  202.         case testItem:
  203.             command = 't';
  204.             modifierMask = testMask;
  205.             break;
  206.         case commentItem:
  207.             command = 'z';
  208.             modifierMask = commentMask;
  209.             break;
  210.         case freshenItem:
  211.             command = 'f';
  212.             modifierMask = freshenMask;
  213.             break;
  214.         case updateItem:
  215.             command = 'u';
  216.             modifierMask = updateMask;
  217.             break;
  218.         case quitItem:
  219.             stop = true;
  220.             break;
  221.         default:
  222.             break;
  223.         }
  224.         break;
  225.  
  226.     case editMenu:
  227.         break;
  228.  
  229.     case modifierMenu:
  230.         switch (theitem) {
  231.         case excludeItem:
  232.             check = -1;
  233.             break;
  234.         case selectItem:
  235.             thedialog = GetNewDialog(selectDialog, nil, (WindowPtr)(-1));
  236.             SetPort(thedialog);
  237.             do
  238.                 ModalDialog(nil, &theitem);
  239.             while ((theitem != okItem) && (theitem != cancelItem));
  240.             if (theitem == okItem) {
  241.                 GetDItem(thedialog, editItem, &itemType, &itemHandle, &itemRect);
  242.                 GetIText(itemHandle, (StringPtr)&fileList);
  243.                 p2cstr(fileList);
  244.             }
  245.             DisposDialog(thedialog);
  246.             check = -1;
  247.             break;
  248.         case quietItem:
  249.             check = (modifiers ^= quietFlag) & quietFlag;
  250.             break;
  251.         case verboseItem:
  252.             check = (modifiers ^= verboseFlag) & verboseFlag;
  253.             break;
  254.         default:
  255.             break;
  256.         }
  257.         if (check == 0)
  258.             CheckItem(modifierHandle, theitem, false);
  259.         else if (check > 0)
  260.             CheckItem(modifierHandle, theitem, true);
  261.         break;
  262.  
  263.     case screenMenu:
  264.         switch (theitem) {
  265.         case pauseItem:
  266.             check = (modifiers ^= pauseFlag) & pauseFlag;
  267.             screenControl("p", check);
  268.             break;
  269.         case scrollItem:
  270.             check = (modifiers ^= scrollFlag) & scrollFlag;
  271.             screenControl("s", check);
  272.             break;
  273.         default:
  274.             break;
  275.         }
  276.         if (check == 0)
  277.             CheckItem(screenHandle, theitem, false);
  278.         else if (check > 0)
  279.             CheckItem(screenHandle, theitem, true);
  280.         break;
  281.  
  282.     case extractMenu:
  283.         switch (theitem) {
  284.         case screenItem:
  285.             check = (modifiers ^= screenFlag) & screenFlag;
  286.             break;
  287.         case junkItem:
  288.             check = (modifiers ^= junkFlag) & junkFlag;
  289.             break;
  290.         default:
  291.             break;
  292.         }
  293.         if (check == 0)
  294.             CheckItem(extractHandle, theitem, false);
  295.         else if (check > 0)
  296.             CheckItem(extractHandle, theitem, true);
  297.         break;
  298.  
  299.     case caseMenu:
  300.         switch (theitem) {
  301.         case insensitiveItem:
  302.             check = (modifiers ^= insensitiveFlag) & insensitiveFlag;
  303.             break;
  304.         case lowercaseItem:
  305.             check = (modifiers ^= lowercaseFlag) & lowercaseFlag;
  306.             break;
  307.         default:
  308.             break;
  309.         }
  310.         if (check == 0)
  311.             CheckItem(caseHandle, theitem, false);
  312.         else if (check > 0)
  313.             CheckItem(caseHandle, theitem, true);
  314.         break;
  315.  
  316.     case convertMenu:
  317.         switch (theitem) {
  318.         case autoItem:
  319.             CheckItem(convertHandle, autoItem, true);
  320.             CheckItem(convertHandle, binaryItem, false);
  321.             CheckItem(convertHandle, textItem, false);
  322.             modifiers &= (allFlags ^ textFlag);
  323.             modifiers |= autoFlag;
  324.             break;
  325.         case binaryItem:
  326.             CheckItem(convertHandle, autoItem, false);
  327.             CheckItem(convertHandle, binaryItem, true);
  328.             CheckItem(convertHandle, textItem, false);
  329.             modifiers &= (allFlags ^ (autoFlag | textFlag));
  330.             break;
  331.         case textItem:
  332.             CheckItem(convertHandle, autoItem, false);
  333.             CheckItem(convertHandle, binaryItem, false);
  334.             CheckItem(convertHandle, textItem, true);
  335.             modifiers &= (allFlags ^ autoFlag);
  336.             modifiers |= textFlag;
  337.             break;
  338.         default:
  339.             break;
  340.         }
  341.         break;
  342.  
  343.     case overwriteMenu:
  344.         switch (theitem) {
  345.         case alwaysItem:
  346.             CheckItem(overwriteHandle, alwaysItem, true);
  347.             CheckItem(overwriteHandle, neverItem, false);
  348.             CheckItem(overwriteHandle, promptItem, false);
  349.             modifiers &= (allFlags ^ neverFlag);
  350.             modifiers |= overwriteFlag;
  351.             break;
  352.         case neverItem:
  353.             CheckItem(overwriteHandle, alwaysItem, false);
  354.             CheckItem(overwriteHandle, neverItem, true);
  355.             CheckItem(overwriteHandle, promptItem, false);
  356.             modifiers &= (allFlags ^ overwriteFlag);
  357.             modifiers |= neverFlag;
  358.             break;
  359.         case promptItem:
  360.             CheckItem(overwriteHandle, alwaysItem, false);
  361.             CheckItem(overwriteHandle, neverItem, false);
  362.             CheckItem(overwriteHandle, promptItem, true);
  363.             modifiers &= (allFlags ^ (neverFlag | overwriteFlag));
  364.             break;
  365.         default:
  366.             break;
  367.         }
  368.         break;
  369.  
  370.     case infoMenu:
  371.         switch (theitem) {
  372.         case prtCommentItem:
  373.             check = (modifiers ^= prtCommentFlag) & prtCommentFlag;
  374.             break;
  375.         case prtHeaderItem:
  376.             check = (modifiers ^= prtHeaderFlag) & prtHeaderFlag;
  377.             break;
  378.         case prtTotalsItem:
  379.             check = (modifiers ^= prtTotalsFlag) & prtTotalsFlag;
  380.             break;
  381.         default:
  382.             break;
  383.         }
  384.         if (check == 0)
  385.             CheckItem(infoHandle, theitem, false);
  386.         else if (check > 0)
  387.             CheckItem(infoHandle, theitem, true);
  388.         break;
  389.  
  390.     case formatMenu:
  391.         switch (theitem) {
  392.         case filenameItem:
  393.             CheckItem(formatHandle, filenameItem, true);
  394.             CheckItem(formatHandle, longItem, false);
  395.             CheckItem(formatHandle, mediumItem, false);
  396.             CheckItem(formatHandle, shortItem, false);
  397.             modifiers &= (allFlags ^ (longFlag | mediumFlag | shortFlag));
  398.             modifiers |= filenameFlag;
  399.             break;
  400.         case longItem:
  401.             CheckItem(formatHandle, filenameItem, false);
  402.             CheckItem(formatHandle, longItem, true);
  403.             CheckItem(formatHandle, mediumItem, false);
  404.             CheckItem(formatHandle, shortItem, false);
  405.             modifiers &= (allFlags ^ (filenameFlag | mediumFlag | shortFlag));
  406.             modifiers |= longFlag;
  407.             break;
  408.         case mediumItem:
  409.             CheckItem(formatHandle, filenameItem, false);
  410.             CheckItem(formatHandle, longItem, false);
  411.             CheckItem(formatHandle, mediumItem, true);
  412.             CheckItem(formatHandle, shortItem, false);
  413.             modifiers &= (allFlags ^ (filenameFlag | longFlag | shortFlag));
  414.             modifiers |= mediumFlag;
  415.             break;
  416.         case shortItem:
  417.             CheckItem(formatHandle, filenameItem, false);
  418.             CheckItem(formatHandle, longItem, false);
  419.             CheckItem(formatHandle, mediumItem, false);
  420.             CheckItem(formatHandle, shortItem, true);
  421.             modifiers &= (allFlags ^ (filenameFlag | longFlag | mediumFlag));
  422.             modifiers |= shortFlag;
  423.             break;
  424.         default:
  425.             break;
  426.         }
  427.         break;
  428.  
  429.     default:
  430.         break;
  431.  
  432.     }
  433.  
  434.     HiliteMenu(0);
  435.     return;
  436. }
  437.  
  438. void dokey(myevent) EventRecord *myevent;
  439. {
  440.     char code;
  441.  
  442.     code = (char)(myevent->message & charCodeMask);
  443.  
  444.     if (myevent->modifiers & cmdKey) {
  445.         if (myevent->what != autoKey) {
  446.             domenu(MenuKey(code));
  447.         }
  448.     }
  449.  
  450.     return;
  451. }
  452.  
  453. void domousedown(myevent) EventRecord *myevent;
  454. {
  455.     WindowPtr whichwindow;
  456.     long code;
  457.  
  458.     code = FindWindow(myevent->where, &whichwindow);
  459.  
  460.     switch (code) {
  461.  
  462.     case inSysWindow:
  463.         SystemClick(myevent, whichwindow);
  464.         break;
  465.  
  466.     case inMenuBar:
  467.         domenu(MenuSelect(myevent->where));
  468.         break;
  469.  
  470.     }
  471.  
  472.     return;
  473. }
  474.  
  475. int main(argc, argv) int argc; char *argv[];
  476. {
  477.     struct Globals saveGlobals;
  478.     Boolean haveEvent, useWNE;
  479.     short markChar;
  480.     FILE *fp;
  481.  
  482.     FlushEvents(everyEvent, 0);
  483.     InitGraf(&qd.thePort);
  484.     InitFonts();
  485.     InitWindows();
  486.     InitMenus();
  487.     TEInit();
  488.     InitDialogs(nil);
  489.     InitCursor();
  490.  
  491.     CONSTRUCTGLOBALS();
  492.  
  493.     sprintf(UnzipVersion, "%d.%d%d%s of %s", UZ_MAJORVER, UZ_MINORVER,
  494.         PATCHLEVEL, BETALEVEL, VERSION_DATE);
  495.     sprintf(ZipinfoVersion, "%d.%d%d%s of %s", ZI_MAJORVER, ZI_MINORVER,
  496.         PATCHLEVEL, BETALEVEL, VERSION_DATE);
  497.  
  498.     c2pstr(UnzipVersion);
  499.     c2pstr(ZipinfoVersion);
  500.  
  501.     SysEnvirons(1, &sysRec);
  502.     useWNE = TrapAvailable(sysRec.machineType, _WaitNextEvent, ToolTrap);
  503.  
  504.     SetMenuBar(menubar = GetNewMBar(unzipMenuBar));
  505.     DisposeHandle(menubar);
  506.     InsertMenu(GetMenu(screenMenu), -1);
  507.     InsertMenu(GetMenu(extractMenu), -1);
  508.     InsertMenu(GetMenu(caseMenu), -1);
  509.     InsertMenu(GetMenu(convertMenu), -1);
  510.     InsertMenu(GetMenu(overwriteMenu), -1);
  511.     InsertMenu(GetMenu(infoMenu), -1);
  512.     InsertMenu(GetMenu(formatMenu), -1);
  513.     AddResMenu(appleHandle = GetMHandle(appleMenu), 'DRVR');
  514.     modifierHandle = GetMHandle(modifierMenu);
  515.     screenHandle = GetMHandle(screenMenu);
  516.     extractHandle = GetMHandle(extractMenu);
  517.     caseHandle = GetMHandle(caseMenu);
  518.     convertHandle = GetMHandle(convertMenu);
  519.     overwriteHandle = GetMHandle(overwriteMenu);
  520.     infoHandle = GetMHandle(infoMenu);
  521.     formatHandle = GetMHandle(formatMenu);
  522.     DrawMenuBar();
  523.  
  524.     screenOpen("Unzip");
  525.  
  526.     modifiers = 0;
  527.  
  528.     GetItemMark(modifierHandle, quietItem, &markChar);
  529.     if (markChar) modifiers ^= quietFlag;
  530.     GetItemMark(modifierHandle, verboseItem, &markChar);
  531.     if (markChar) modifiers ^= verboseFlag;
  532.  
  533.     GetItemMark(screenHandle, pauseItem, &markChar);
  534.     if (markChar) modifiers ^= pauseFlag;
  535.     screenControl("p", markChar);
  536.     GetItemMark(screenHandle, scrollItem, &markChar);
  537.     if (markChar) modifiers ^= scrollFlag;
  538.     screenControl("s", markChar);
  539.  
  540.     GetItemMark(extractHandle, screenItem, &markChar);
  541.     if (markChar) modifiers ^= screenFlag;
  542.     GetItemMark(extractHandle, junkItem, &markChar);
  543.     if (markChar) modifiers ^= junkFlag;
  544.  
  545.     GetItemMark(caseHandle, insensitiveItem, &markChar);
  546.     if (markChar) modifiers ^= insensitiveFlag;
  547.     GetItemMark(caseHandle, lowercaseItem, &markChar);
  548.     if (markChar) modifiers ^= lowercaseFlag;
  549.  
  550.     GetItemMark(convertHandle, autoItem, &markChar);
  551.     if (markChar) modifiers ^= autoFlag;
  552.     GetItemMark(convertHandle, textItem, &markChar);
  553.     if (markChar) modifiers ^= textFlag;
  554.  
  555.     if ((modifiers & (autoFlag | textFlag)) == (autoFlag | textFlag)) {
  556.         CheckItem(convertHandle, textItem, false);
  557.         modifiers &= (allFlags ^ textFlag);
  558.     } else if (modifiers & (autoFlag | textFlag))
  559.         CheckItem(convertHandle, binaryItem, false);
  560.     else
  561.         CheckItem(convertHandle, binaryItem, true);
  562.  
  563.     GetItemMark(overwriteHandle, alwaysItem, &markChar);
  564.     if (markChar) modifiers ^= overwriteFlag;
  565.     GetItemMark(overwriteHandle, neverItem, &markChar);
  566.     if (markChar) modifiers ^= neverFlag;
  567.  
  568.     if ((modifiers & (neverFlag | overwriteFlag)) == (neverFlag | overwriteFlag)) {
  569.         CheckItem(overwriteHandle, alwaysItem, false);
  570.         CheckItem(overwriteHandle, neverItem, false);
  571.         CheckItem(overwriteHandle, promptItem, true);
  572.         modifiers &= (allFlags ^ (neverFlag | overwriteFlag));
  573.     } else if (modifiers & (neverFlag | overwriteFlag))
  574.         CheckItem(overwriteHandle, promptItem, false);
  575.     else
  576.         CheckItem(overwriteHandle, promptItem, true);
  577.  
  578.     GetItemMark(infoHandle, prtCommentItem, &markChar);
  579.     if (markChar) modifiers ^= prtCommentFlag;
  580.     GetItemMark(infoHandle, prtHeaderItem, &markChar);
  581.     if (markChar) modifiers ^= prtHeaderFlag;
  582.     GetItemMark(infoHandle, prtTotalsItem, &markChar);
  583.     if (markChar) modifiers ^= prtTotalsFlag;
  584.  
  585.     GetItemMark(formatHandle, filenameItem, &markChar);
  586.     if (markChar) modifiers ^= filenameFlag;
  587.     GetItemMark(formatHandle, longItem, &markChar);
  588.     if (markChar) modifiers ^= longFlag;
  589.     GetItemMark(formatHandle, mediumItem, &markChar);
  590.     if (markChar) modifiers ^= mediumFlag;
  591.     GetItemMark(formatHandle, shortItem, &markChar);
  592.     if (markChar) modifiers ^= shortFlag;
  593.  
  594.     if (modifiers & longFlag) {
  595.         CheckItem(formatHandle, filenameItem, false);
  596.         CheckItem(formatHandle, mediumItem, false);
  597.         CheckItem(formatHandle, shortItem, false);
  598.         modifiers &= (allFlags ^ (filenameFlag | mediumFlag | shortFlag));
  599.     } else if (modifiers & mediumFlag) {
  600.         CheckItem(formatHandle, filenameItem, false);
  601.         CheckItem(formatHandle, shortItem, false);
  602.         modifiers &= (allFlags ^ (filenameFlag | shortFlag));
  603.     } else if (modifiers & shortFlag) {
  604.         CheckItem(formatHandle, filenameItem, false);
  605.         modifiers &= (allFlags ^ filenameFlag);
  606.     } else if (! (modifiers & filenameFlag)) {
  607.         CheckItem(formatHandle, shortItem, false);
  608.         modifiers |= shortFlag;
  609.     }
  610.  
  611.     command = ' ';
  612.  
  613.     stop = false;
  614.     while (!stop) {
  615.         SetCursor(&qd.arrow);
  616.  
  617.         if (useWNE) {
  618.             haveEvent = WaitNextEvent(everyEvent, &myevent, MAXLONG, NULL);
  619.         } else {
  620.             SystemTask();
  621.             haveEvent = GetNextEvent(everyEvent, &myevent);
  622.         }
  623.  
  624.         if (haveEvent) {
  625.             switch (myevent.what) {
  626.  
  627.             case activateEvt:
  628.                 break;
  629.  
  630.             case keyDown:
  631.             case autoKey:
  632.                 dokey(&myevent);
  633.                 break;
  634.  
  635.             case mouseDown:
  636.                 domousedown(&myevent);
  637.                 break;
  638.  
  639.             case updateEvt:
  640.                 screenUpdate(myevent.message);
  641.                 break;
  642.  
  643.             case mouseUp:
  644.             case keyUp:
  645.                 break;
  646.  
  647.             default:
  648.                 break;
  649.  
  650.             }
  651.         }
  652.  
  653.         if (command != ' ') {
  654.             char *s, **v, modifierString[32];
  655.             SFReply fileRep;
  656.             Point p;
  657.             int m, n;
  658.  
  659.             SetPt(&p, 40, 40);
  660.  
  661.             SFGetFile(p, "\pSpecify ZIP file:", 0L, -1, nil, 0L, &fileRep);
  662.             if (fileRep.good) {
  663.                 MacFSTest(fileRep.vRefNum);
  664.                 ResolveMacVol(fileRep.vRefNum, &G.gnVRefNum, &G.glDirID, NULL);
  665.  
  666.                 p2cstr((Ptr)fileRep.fName);
  667.  
  668.                 modifierMask &= modifiers;
  669.  
  670.                 s = modifierString;
  671.  
  672.                 *s++ = '-';
  673.                 if ((command != 'x') && (command != 'Z')) *s++ = command;
  674.  
  675.                 if (modifierMask) {
  676.                     if (modifierMask & (autoFlag | textFlag)) *s++ = 'a';
  677.                     if (modifierMask & textFlag) *s++ = 'a';
  678.                     if (modifierMask & insensitiveFlag) *s++ = 'C';
  679.                     if (!G.HFSFlag || (modifierMask & junkFlag)) *s++ = 'j';
  680.                     if (modifierMask & lowercaseFlag) *s++ = 'L';
  681.                     if (modifierMask & neverFlag) *s++ = 'n';
  682.                     if (modifierMask & overwriteFlag) *s++ = 'o';
  683.                     if (modifierMask & quietFlag) *s++ = 'q';
  684.                     if (modifierMask & verboseFlag) *s++ = 'v';
  685.  
  686.                     if (modifierMask & prtCommentFlag) *s++ = 'z';
  687.                     if (modifierMask & prtHeaderFlag) *s++ = 'h';
  688.                     if (modifierMask & prtTotalsFlag) *s++ = 't';
  689.                     if (modifierMask & filenameFlag) *s++ = '2';
  690.                     if (modifierMask & longFlag) *s++ = 'l';
  691.                     if (modifierMask & mediumFlag) *s++ = 'm';
  692.                     if (modifierMask & shortFlag) *s++ = 's';
  693.                 }
  694.  
  695.                 if (*(s - 1) == '-') s -= 1;
  696.  
  697.                 *s = '\0';
  698.  
  699.                 v = (char **)malloc(sizeof(char *));
  700.                 *v = "unzip";
  701.                 argc = 1;
  702.  
  703.                 envargs(&argc, &v, NULL, NULL);
  704.  
  705.                 argv = (char **)malloc((argc + 3) * sizeof(char *));
  706.  
  707.                 argv[m = 0] = (command == 'Z') ? "zipinfo" : "unzip";
  708.                 if (*modifierString) argv[++m] = modifierString;
  709.                 argv[++m] = (char *)fileRep.fName;
  710.                 for (n = 1; n < argc; n++) argv[n + m] = v[n];
  711.                 argv[argc += m] = NULL;
  712.  
  713.                 free(v);
  714.  
  715.                 for (n = 0; argv[n] != NULL; n++) printf("%s ", argv[n]);
  716.                 printf("...\n\n");
  717.  
  718.                 memcpy(&saveGlobals, &G, sizeof(struct Globals));
  719.  
  720.                 unzip(__G__ argc, argv);
  721.                 
  722.                 memcpy(&G, &saveGlobals, sizeof(struct Globals));
  723.  
  724.                 printf("\nDone\n");
  725.             }
  726.  
  727.             fileList[0] = '\0';
  728.             command = ' ';
  729.         }
  730.     }
  731.  
  732.     screenClose();
  733.  
  734.     DESTROYGLOBALS()
  735.  
  736.     ExitToShell();
  737. }
  738.